#include "Jeu.h"
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>

void InitialisationJeu (Jeu * j)
{
	(*j).lien_sur_terrain = (Terrain*) malloc (sizeof (Terrain));
	InitialisationTerrain ((*j).lien_sur_terrain, 16,10);
	(*j).tableau_de_joueurs = (Joueur*) malloc (2*sizeof(Joueur));
	InitialisationJoueur(&(*j).tableau_de_joueurs[0]);
	InitialisationJoueur(&(*j).tableau_de_joueurs[1]);
	(*j).tour = 0;
	
}

Terrain * ObtientTerrainJeu(Jeu * j)
{
  return ((*j).lien_sur_terrain);
}


const Terrain * ObtientTerrainConstJeu(Jeu * j)
{
  return ((*j).lien_sur_terrain);
}


void RecherchePossibiliteDeplacement (Jeu * j, int * possibilite,int x, int y)
{
	int i;
	int k;
	Terrain * t = ObtientTerrainJeu (j);
	int modification = 1;
	int maximum;
	assert(0<=x && x<=(*t).dimx);
	assert(0<=y && y<=(*t).dimy);
	for (i=0; i<(*t).dimy; i++)
	{
		for (k=0; k<(*t).dimx; k++)
		{
			if (k == x && i == y)
			{
				possibilite[i*(*t).dimx+k] = (*(*t).cases[y*(*t).dimx+x].lunite).deplacement + 2;
				
			}
			else
			{
				possibilite[i*(*t).dimx+k] = 0;
			}
		}
	}
	while (modification != 0)
	{
		modification = 0;
		for (i=0; i< (*t).dimy; i++)
		{
			for (k=0;k<(*t).dimx;k++)
			{
				maximum = 0;
				if (k > 0)
				{
					if (possibilite[i*(*t).dimx+k-1]> 0)
					{
						maximum = possibilite[i*(*t).dimx+k-1];
					}
				}
				if (i > 0)
				{
					if (possibilite[(i-1)*(*t).dimx+k] > 0)
					{
						if (maximum == 0)
						{
							maximum = possibilite[(i-1)*(*t).dimx+k];
						}
						else
						{
							if (maximum < possibilite[(i-1)*(*t).dimx+k])
							{
								maximum = possibilite[(i-1)*(*t).dimx+k];
							}
						}
					}
				}
				if (i < (*t).dimy-1)
				{
					if (possibilite[(i+1)*(*t).dimx+k] > 0)
					{
						if (maximum == 0)
						{
							maximum = possibilite[(i+1)*(*t).dimx+k];
						}
						else
						{
							if (maximum < possibilite[(i+1)*(*t).dimx+k])
							{
								maximum = possibilite[(i+1)*(*t).dimx+k];
							}
						}
					}
				}
				if (k < (*t).dimx-1)
				{
					if (possibilite[i*(*t).dimx+k+1] > 0)
					{
						if (maximum == 0)
						{
							maximum = possibilite[i*(*t).dimx+k+1];
						}
						else
						{
							if (maximum < possibilite[i*(*t).dimx+k+1])
							{
								maximum = possibilite[i*(*t).dimx+k+1];
							}
						}
					}
				}
				if (maximum -1 > 0 && possibilite[i*(*t).dimx+k] == 0)
				{
					if ((*t).cases[i*(*t).dimx+k].type_decor == 0 || (*t).cases[i*(*t).dimx+k].type_decor == 4)
					{
						if ((*t).cases[i*(*t).dimx+k].lunite != NULL)
						{
							if ((*(*t).cases[i*(*t).dimx+k].lunite).equipe != (*(*t).cases[y*(*t).dimx+x].lunite).equipe)
							{
								possibilite[i*(*t).dimx+k] = 1;
							}
							else
							{
								possibilite[i*(*t).dimx+k] = 0;
							}
						}
						else
						{
							possibilite[i*(*t).dimx+k] = maximum - 1;
							modification++;
						}
					}
					else
					{
						possibilite[i*(*t).dimx+k] = 1;
					}

				}
			}
		}		
	}
}


void ChangementTour(Jeu * j)
{
  Terrain * t = ObtientTerrainJeu(j);
  int i = 0;
  int k = 0;
  (*j).tour = (*j).tour + 1;
  
  for(i=0;i<(*t).dimy;i++)
  {
     for(k=0;k<(*t).dimx;k++)
     {
       if((*t).cases[i*(*t).dimx+k].lunite != NULL)
       {
         (*(*t).cases[i*(*t).dimx+k].lunite).utilise = 0;
       }
       if ((*t).cases[i*(*t).dimx+k].type_decor == 3 && (*j).tour%2 == (*t).cases[i*(*t).dimx+k].groupe_decor)
			{
				(*t).cases[i*(*t).dimx+k].type_decor = 4;
			}
     }
  }

}


int VerificationFinJeu (Jeu * j)
{
	if ((*j).tableau_de_joueurs[0].nombre_unites == 0 || (*j).tableau_de_joueurs[1].nombre_unites == 0)
	{
		return 0;
	}
	return 1;
}


void ChargementJeu(Jeu * j, const char * nomfic)
{
	int i;
	int k;
	int recup;
	int dimx;
	int dimy;
	float recup2;
	FILE * fic = fopen(nomfic,"r");
	Terrain * t = ObtientTerrainJeu(j);
	if(fic == NULL)
	{
		printf("ERROR \n");
		exit(EXIT_FAILURE);	
	}
	
	
	fscanf(fic ,"%d\n\n", &recup);
	(*j).tour = recup;
	fscanf(fic ,"%d ", &recup);
	dimy = recup;
	fscanf(fic ,"%d\n\n", &recup);
	dimx = recup;
	DestructionTerrain (t);
	InitialisationTerrain (t,dimx,dimy);
	fscanf(fic ,"%d\n\n", &recup);
	(*j).mapencours = recup;
	fscanf(fic ,"%d ", &recup);
	(*j).tableau_de_joueurs[0].bois = recup;
	fscanf(fic ,"%d ", &recup);
	(*j).tableau_de_joueurs[0].nourriture = recup;
	fscanf(fic ,"%d ", &recup);
	(*j).tableau_de_joueurs[0].nombre_unites = recup;
	fscanf(fic ,"%d ", &recup);
	(*j).tableau_de_joueurs[0].nombre_batiments = recup;
	fscanf(fic ,"%d\n\n", &recup);
	(*j).tableau_de_joueurs[0].joueur_ou_IA = recup;
	
	fscanf(fic ,"%d ", &recup);
	(*j).tableau_de_joueurs[1].bois = recup;
	fscanf(fic ,"%d ", &recup);
	(*j).tableau_de_joueurs[1].nourriture = recup;
	fscanf(fic ,"%d ", &recup);
	(*j).tableau_de_joueurs[1].nombre_unites = recup;
	fscanf(fic ,"%d ", &recup);
	(*j).tableau_de_joueurs[1].nombre_batiments = recup;
	fscanf(fic ,"%d\n\n", &recup);
	(*j).tableau_de_joueurs[1].joueur_ou_IA = recup;
	
	for (i=0; i< (*t).dimy;i++)
	{
		for (k=0; k< (*t).dimx; k++)
		{
			fscanf(fic ,"%d", &recup);
			(*t).cases[i*(*t).dimx+k].type_decor = recup;
			fscanf(fic ,"%d", &recup);
			(*t).cases[i*(*t).dimx+k].vie = recup;
			fscanf(fic ,"%d", &recup);
			(*t).cases[i*(*t).dimx+k].groupe_decor = recup;
		}
	}
	
	for (i=0; i< (*t).dimy;i++)
	{
		for (k=0; k< (*t).dimx; k++)
		{
			fscanf(fic ,"%d", &recup);
			if (recup == 0)
			{
				(*t).cases[i*(*t).dimx+k].lunite = NULL;
			}
			else
			{
				(*t).cases[i*(*t).dimx+k].lunite = (Unite*) malloc (sizeof (Unite));
				(*(*t).cases[i*(*t).dimx+k].lunite).type = recup;
				fscanf(fic ,"%d", &recup);
				(*(*t).cases[i*(*t).dimx+k].lunite).vie = recup;
				fscanf(fic ,"%f", &recup2);
				(*(*t).cases[i*(*t).dimx+k].lunite).attaque = recup2;
				fscanf(fic ,"%d", &recup);
				(*(*t).cases[i*(*t).dimx+k].lunite).defense = recup;
				fscanf(fic ,"%d", &recup);
				(*(*t).cases[i*(*t).dimx+k].lunite).deplacement = recup;
				fscanf(fic ,"%d", &recup);
				(*(*t).cases[i*(*t).dimx+k].lunite).equipe = recup;
				fscanf(fic ,"%d", &recup);
				(*(*t).cases[i*(*t).dimx+k].lunite).utilise = recup;
				
			}
		}
	}
	fclose(fic);
	
}


void DestructionJeu(Jeu *j)
{
   DestructionTerrain((*j).lien_sur_terrain);
   free((*j).lien_sur_terrain);
   free((*j).tableau_de_joueurs);
   (*j).tour = 0;
} 


void IntelligenceArtificielle (Jeu * j)
{   
    Terrain * t = ObtientTerrainJeu(j);
	int i = 0;
	int k = 0;
	int nbpecheur = 0;
	int nbbucheron = 0;
	int nbinfanterie = 0;
	int nbinfanterie2 = 0;
	int nbinfanterie3 = 0;
	
	int nbinfanterieinv = 0;
	int nbinfanterieinv2 = 0;
	int nbinfanterieinv3 = 0;
	
	int nbarbre = 0;
	for(i=0;i<(*t).dimy;i++)
	{
		for(k=0;k<(*t).dimx;k++) 
	    {
	    	if((*t).cases[i*(*t).dimx+k].lunite != NULL)
	    	{
	    		if ((*(*t).cases[i*(*t).dimx+k].lunite).equipe == (*j).tour%2 && (*(*t).cases[i*(*t).dimx+k].lunite).utilise == 0)
	    		{
	    			(*(*t).cases[i*(*t).dimx+k].lunite).utilise = 1;
	    			switch((*(*t).cases[i*(*t).dimx+k].lunite).type)
	    			{
	    			  case 1: 
	    			  	Radar(j,k,i,1);
	    			  	nbbucheron++;
	    			  break;
	    			  case 2: 
	    			  	Radar(j,k,i,2);
	    			  	nbpecheur++;
	    			  break;
	    			  case 3: 
	    			  	Radar(j,k,i,3);
	    			  	nbinfanterie++;
	    			  break;
	    			   case 4: 
	    			  	Radar(j,k,i,3);
	    			  	nbinfanterie2++;
	    			  break;
	    			   case 5: 
	    			  	Radar(j,k,i,3);
	    			  	nbinfanterie3++;
	    			  break;
	    			}
	    		}
	    		else if ((*(*t).cases[i*(*t).dimx+k].lunite).equipe != (*j).tour%2)
	    		{	
	    			switch((*(*t).cases[i*(*t).dimx+k].lunite).type)
	    			{
	    			  case 3: 
	    			  	nbinfanterieinv++;
	    			  break;
	    			  case 4: 
	    			  	nbinfanterieinv2++;
	    			  break;
	    			  case 5: 
	    			  	nbinfanterieinv3++;
	    			  break;
	    			}
	    		}
			}
			if ((*t).cases[i*(*t).dimx+k].type_decor == 1)
	    	{
	    		nbarbre++;
	    	}
	    }
	}
	if ((*j).tableau_de_joueurs[(*j).tour%2].nombre_batiments == 0)
	{
		if ((*j).tableau_de_joueurs[(*j).tour%2].bois >= 100)
		{
			for(i=0;i<(*t).dimy;i++)
			{
				for(k=0;k<(*t).dimx;k++) 
	   		 	{
	   		 		AjouterMaisonJeu (j, 1, k,i);
				}
			}
		}
	}
	else
	{
		if ((*j).tableau_de_joueurs[(*j).tour%2].bois >= 100 && (*j).tableau_de_joueurs[(*j).tour%2].nombre_batiments < 3)
		{
			for(i=0;i<(*t).dimy;i++)
			{
				for(k=0;k<(*t).dimx;k++) 
	   		 	{
	   		 		AjouterMaisonJeu (j, 1,k,i);
				}
			}
		}
		for(i=0;i<(*t).dimy;i++)
		{
			for(k=0;k<(*t).dimx;k++) 
	   	 	{
	   	 		
	   	 		if ((*t).cases[i*(*t).dimx+k].type_decor == 4 && (*t).cases[i*(*t).dimx+k].groupe_decor == (*j).tour%2 && (*t).cases[i*(*t).dimx+k].lunite == NULL)
	    		{
	    			if (nbpecheur == 0 && (*j).tableau_de_joueurs[(*j).tour%2].nourriture >= 50)
	    			{
	    				CreationUniteCases (&(*t).cases[i*(*t).dimx+k],2,(*j).tour%2);
						ModificationReserveNourriture (&(*j).tableau_de_joueurs[(*j).tour%2],-50);
						ModificationNombreUnites (&(*j).tableau_de_joueurs[(*j).tour%2],1);
						nbpecheur++;
	    			}
	    			else if (nbinfanterieinv2 > 0 || nbinfanterieinv3 > 0)
	    			{
	    				if ((*j).tableau_de_joueurs[(*j).tour%2].nourriture >= 200)
	    				{
	    					CreationUniteCases (&(*t).cases[i*(*t).dimx+k],5,(*j).tour%2);
							ModificationReserveNourriture (&(*j).tableau_de_joueurs[(*j).tour%2],-200);
							ModificationNombreUnites (&(*j).tableau_de_joueurs[(*j).tour%2],1);
							nbinfanterie3++;
	    				}
	    			}
	    			else if (nbinfanterieinv > 1)
	    			{
	    				if ((*j).tableau_de_joueurs[(*j).tour%2].nourriture >= 150)
	    				{
	    					CreationUniteCases (&(*t).cases[i*(*t).dimx+k],4,(*j).tour%2);
							ModificationReserveNourriture (&(*j).tableau_de_joueurs[(*j).tour%2],-150);
							ModificationNombreUnites (&(*j).tableau_de_joueurs[(*j).tour%2],1);
							nbinfanterie2++;
	    				}
	    			}
	    			else if (nbbucheron == 0 && (*j).tableau_de_joueurs[(*j).tour%2].nourriture >= 50 && nbarbre > 0 && (*j).tableau_de_joueurs[(*j).tour%2].nombre_batiments < 3)
	    			{
	    				CreationUniteCases (&(*t).cases[i*(*t).dimx+k],1,(*j).tour%2);
						ModificationReserveNourriture (&(*j).tableau_de_joueurs[(*j).tour%2],-50);
						ModificationNombreUnites (&(*j).tableau_de_joueurs[(*j).tour%2],1);
						nbbucheron++;
	    			}
	    			else if ((*j).tableau_de_joueurs[(*j).tour%2].nourriture >= 100)
	    			{
	    				
	    				CreationUniteCases (&(*t).cases[i*(*t).dimx+k],3,(*j).tour%2);
						ModificationReserveNourriture (&(*j).tableau_de_joueurs[(*j).tour%2],-100);
						ModificationNombreUnites (&(*j).tableau_de_joueurs[(*j).tour%2],1);
	    			}
	   	 		}
	   	 		
			}
		}	
	}
}


void Radar (Jeu * j, int x, int y, int type)
{
	int i;
	int k;
	int retour;
	int xpos = -1;
	int ypos = -1;
	int position = 0;
	int deplacement = 0;
	int direction;
	int ok = 1;
	int x2 = x;
	int y2 = y;
	int maximum;
	Terrain * t = ObtientTerrainJeu(j);
	Cases * cdepart = NULL;
	Cases * cfin = NULL;
	int * possibilite = (int*) malloc ((*t).dimx * (*t).dimy *sizeof (int));
	assert(0<=x && x<(*t).dimx);
	assert(0<=y && y<(*t).dimy);
	assert(1<=type && type<=3);
	RemplissageMap(j,possibilite,x,y,type,x,y);
	for(i = 0 ; i< (*t).dimy ; i++)
	{
		for (k = 0 ; k < (*t).dimx; k++)
		{
			if (type == 2)
			{
				if ((*t).cases[i*(*t).dimx+k].type_decor == type||(*t).cases[i*(*t).dimx+k].type_decor == 5||(*t).cases[i*(*t).dimx+k].type_decor == 6||(*t).cases[i*(*t).dimx+k].type_decor == 7||(*t).cases[i*(*t).dimx+k].type_decor == 8)
				{
					if (possibilite[i*(*t).dimx+k] > position)
					{
						xpos = k;
						ypos = i;
						position = possibilite[i*(*t).dimx+k];
					}
				}
			}
			else if (type == 1)
			{
				if ((*t).cases[i*(*t).dimx+k].type_decor == type)
				{
					if (possibilite[i*(*t).dimx+k] > position)
					{
						xpos = k;
						ypos = i;
					position = possibilite[i*(*t).dimx+k];
					}
				}
			}
			else
			{
				if ((*t).cases[i*(*t).dimx+k].lunite != NULL)
				{
					if ((*(*t).cases[i*(*t).dimx+k].lunite).equipe != (*j).tour %2)
					{
						if (possibilite[i*(*t).dimx+k] > position)
						{
							xpos = k;
							ypos = i;
							position = possibilite[i*(*t).dimx+k];
						}
					}
				}
			}
		}
	}
	if (!(xpos == -1 && ypos == -1))
	{
	 RemplissageMap(j,possibilite,xpos,ypos,-1,x,y);
	
	deplacement = (*(*t).cases[y*(*t).dimx+x].lunite).deplacement;
	ok = 1;
	x2 = x;
	y2 = y;
	maximum = possibilite[y2*(*t).dimx+x2];
	while (deplacement > 0 && ok == 1)
	{
		if (1000 - maximum == 1)
		{
			ok = 0;
		}
		if (ok == 1)
		{
		if (y2 > 0)
		{
			if (possibilite[(y2-1)*(*t).dimx+x2] > 0)
			{
				maximum = possibilite[(y2-1)*(*t).dimx+x2];
				direction = 2;
			}
		}
		if (y2 < (*t).dimy-1)
		{
			if (possibilite[(y2+1)*(*t).dimx+x2] > 0)
			{
				if (maximum > 0)
				{
					if (maximum < possibilite[(y2+1)*(*t).dimx+x2])
					{
						maximum = possibilite[(y2+1)*(*t).dimx+x2];
						direction = 4;
					}
				}
				else
				{
					maximum = possibilite[(y2+1)*(*t).dimx+x2];
					direction = 4;
				}
			}
		}
		if (x2 > 0)
		{
			if (possibilite[y2*(*t).dimx+x2-1] > 0)
			{
				if (maximum > 0)
				{
					if (maximum < possibilite[y2*(*t).dimx+x2-1])
					{
						maximum = possibilite[y2*(*t).dimx+x2-1];
						direction = 3;
					}
				}
				else
				{
					maximum = possibilite[y2*(*t).dimx+x2-1];
					direction = 3;
				}
			}
		}
		if (x2 < (*t).dimx -1)
		{
			if (possibilite[y2*(*t).dimx+x2+1] > 0)
			{
				if (maximum > 0)
				{
					if (maximum < possibilite[y2*(*t).dimx+x2+1])
					{
						maximum = possibilite[y2*(*t).dimx+x2+1];
						direction = 1;
					}
				}
				else
				{
					maximum = possibilite[y2*(*t).dimx+x2+1];
					direction = 1;
				}
			}
		}
		deplacement--;
		switch (direction)
		{
			case 1 :
				x2++;
			break;
			case 2 :
				y2--;
			break;
			case 3 :
				x2--;
			break;
			case 4 :
				y2++;
			break;
		}
		}
		
	}
	
	cdepart = ObtientCasesTerrain (t, x, y);
	cfin = ObtientCasesTerrain (t, x2, y2);
	if (!(x == x2 && y == y2))
	{
		DeplacementUniteCases (cdepart, cfin);
	}
	if (ok == 0)
	{
		if (type == 1)
		{
			ActionUniteCases(cfin,&(*t).cases[ypos*(*t).dimx+xpos],1);
			ModificationReserveBois (&(*j).tableau_de_joueurs[(*j).tour%2],20);
		}
		if (type == 2)
		{
			ModificationReserveNourriture (&(*j).tableau_de_joueurs[(*j).tour%2],40);
		}
		if (type == 3)
		{
			retour = ActionUniteCases(cfin,&(*t).cases[ypos*(*t).dimx+xpos],2);
			if (retour == 1)
			{
				 ModificationNombreUnites(&(*j).tableau_de_joueurs[(*j).tour%2], -1);
			}
			else if (retour == 2)
			{
				 ModificationNombreUnites(&(*j).tableau_de_joueurs[((*j).tour+1)%2], -1);
			}
		}
	}
	}
}


void RemplissageMap (Jeu * j, int * possibilite, int x, int y, int type,int x2, int y2)
{
	Terrain * t = ObtientTerrainJeu (j);
	int i;
	int k;
	int modification = 1;
	int maximum;
	for (i=0; i<(*t).dimy; i++)
	{
		for (k=0; k<(*t).dimx; k++)
		{
			if (k == x && i == y)
			{
				possibilite[i*(*t).dimx+k] = 1000;
				
			}
			else
			{
				possibilite[i*(*t).dimx+k] = 0;
			}
		}
	}
	while (modification != 0)
	{
		modification = 0;
		for (i=0; i< (*t).dimy; i++)
		{
			for (k=0;k<(*t).dimx;k++)
			{
				maximum = 0;
				if (k > 0)
				{
					if (possibilite[i*(*t).dimx+k-1]> 0)
					{
						maximum = possibilite[i*(*t).dimx+k-1];
					}
				}
				if (i > 0)
				{
					if (possibilite[(i-1)*(*t).dimx+k] > 0)
					{
						if (maximum == 0)
						{
							maximum = possibilite[(i-1)*(*t).dimx+k];
						}
						else
						{
							if (maximum < possibilite[(i-1)*(*t).dimx+k])
							{
								maximum = possibilite[(i-1)*(*t).dimx+k];
							}
						}
					}
				}
				if (i < (*t).dimy-1)
				{
					if (possibilite[(i+1)*(*t).dimx+k] > 0)
					{
						if (maximum == 0)
						{
							maximum = possibilite[(i+1)*(*t).dimx+k];
						}
						else
						{
							if (maximum < possibilite[(i+1)*(*t).dimx+k])
							{
								maximum = possibilite[(i+1)*(*t).dimx+k];
							}
						}
					}
				}
				if (k < (*t).dimx-1)
				{
					if (possibilite[i*(*t).dimx+k+1] > 0)
					{
						if (maximum == 0)
						{
							maximum = possibilite[i*(*t).dimx+k+1];
						}
						else
						{
							if (maximum < possibilite[i*(*t).dimx+k+1])
							{
								maximum = possibilite[i*(*t).dimx+k+1];
							}
						}
					}
				}
				if (maximum -1 > 0 && possibilite[i*(*t).dimx+k] == 0)
				{
					if ((*t).cases[i*(*t).dimx+k].type_decor == 0 || (*t).cases[i*(*t).dimx+k].type_decor == 4)
					{
						if ((*t).cases[i*(*t).dimx+k].lunite != NULL)
						{
							if (i == y2 && k == x2)
							{
								possibilite[i*(*t).dimx+k] = maximum - 1;
								modification++;
							}
							else
							{
								if ((*(*t).cases[i*(*t).dimx+k].lunite).equipe != (*j).tour%2 && type == 3)
								{
									possibilite[i*(*t).dimx+k] = maximum - 1;
									modification++;
								}
								else
								{
									possibilite[i*(*t).dimx+k] = 0;
								}
							}
						}
						else
						{
							possibilite[i*(*t).dimx+k] = maximum - 1;
							modification++;
						}
					}
					else
					{
						if (type == 2)
						{
							if ((*t).cases[i*(*t).dimx+k].type_decor == type||(*t).cases[i*(*t).dimx+k].type_decor == 5||(*t).cases[i*(*t).dimx+k].type_decor == 6||(*t).cases[i*(*t).dimx+k].type_decor == 7||(*t).cases[i*(*t).dimx+k].type_decor == 8)
							{
								possibilite[i*(*t).dimx+k] = maximum - 1;
								modification++;
							}
						}
						else if (type == 1)
						{
							if ((*t).cases[i*(*t).dimx+k].type_decor == type)
							{
								possibilite[i*(*t).dimx+k] = maximum - 1;
								modification++;
							}
						}
						else
						{
							possibilite[i*(*t).dimx+k] = 0;
						}
					}

				}
			}
		}		
	}
	
}


void AjouterMaisonJeu (Jeu * j, int selectionmaison, int x,int y)
{
	Terrain * t = ObtientTerrainJeu (j);
	Cases * c = ObtientCasesTerrain (t,x,y);
	Cases * c2;
	int ok =0;
	assert(0<=x && x<(*t).dimx);
	assert(0<=y && y<(*t).dimy);
	
	if (x > 0)
	{
		c2 = ObtientCasesTerrain (t,x-1,y);
		if ((*c2).lunite != NULL)
		{
			if ((*(*c2).lunite).equipe == (*j).tour%2)
			{
				ok++;
			}
		}
	}
	if (y > 0)
	{
		c2 = ObtientCasesTerrain (t,x,y-1);
		if ((*c2).lunite != NULL)
		{
			if ((*(*c2).lunite).equipe == (*j).tour%2)
			{
				ok++;
			}
		}	
	}
	if (x < (*t).dimx-1)
	{
		c2 = ObtientCasesTerrain (t,x+1,y);
		if ((*c2).lunite != NULL)
		{
			if ((*(*c2).lunite).equipe == (*j).tour%2)
			{
				ok++;
			}
		}	
	}
	if (y < (*t).dimy-1)
	{
		c2 = ObtientCasesTerrain (t,x,y+1);
		if ((*c2).lunite != NULL)
		{
			if ((*(*c2).lunite).equipe == (*j).tour%2)
			{
				ok++;
			}
		}	
	}
	if ((*c).type_decor == 0 && (*c).lunite == NULL && ok != 0)
	{
		if (selectionmaison == 1 && (*j).tableau_de_joueurs[(*j).tour%2].bois >= 100)
		{
			ModificationDecor (c, 3, (*j).tour%2);
		 	ModificationReserveBois (&(*j).tableau_de_joueurs[(*j).tour%2],-100);
		 	ModificationNombreBatiments (&(*j).tableau_de_joueurs[(*j).tour%2],1);
		 }
	}
}


void SauvegardeJeu(Jeu * j, const char * nomfic)
{
	int i;
	int k;
	int recup;
	float recup2;
	FILE * fic = fopen(nomfic,"w");
	const Terrain * t = ObtientTerrainConstJeu(j);
	if(fic == NULL)
	{
		printf("ERROR \n");
		exit(EXIT_FAILURE);	
	}
	
	recup = (*j).tour;
	fprintf(fic ,"%d\n\n", recup);
	
	recup = (*t).dimy;
	fprintf(fic ,"%d ", recup);
	recup = (*t).dimx;
	fprintf(fic ,"%d\n\n", recup);
	
	recup = (*j).mapencours;
	fprintf(fic ,"%d\n\n", recup);
	
	recup = (*j).tableau_de_joueurs[0].bois;
	fprintf(fic ,"%d ", recup);
	recup = (*j).tableau_de_joueurs[0].nourriture;
	fprintf(fic ,"%d ", recup);
	recup = (*j).tableau_de_joueurs[0].nombre_unites;
	fprintf(fic ,"%d ", recup);
	recup = (*j).tableau_de_joueurs[0].nombre_batiments;
	fprintf(fic ,"%d ", recup);
	recup = (*j).tableau_de_joueurs[0].joueur_ou_IA;
	fprintf(fic ,"%d\n\n", recup);
	
	recup = (*j).tableau_de_joueurs[1].bois;
	fprintf(fic ,"%d ", recup);
	recup = (*j).tableau_de_joueurs[1].nourriture;
	fprintf(fic ,"%d ", recup);
	recup = (*j).tableau_de_joueurs[1].nombre_unites;
	fprintf(fic ,"%d ", recup);
	recup = (*j).tableau_de_joueurs[1].nombre_batiments;
	fprintf(fic ,"%d ", recup);
	recup = (*j).tableau_de_joueurs[1].joueur_ou_IA;
	fprintf(fic ,"%d\n\n", recup);
	
	
	for (i=0; i< (*t).dimy;i++)
	{
		for (k=0; k< (*t).dimx; k++)
		{
			
			recup = (*t).cases[i*(*t).dimx+k].type_decor;
			fprintf(fic ,"%d ", recup);
			recup = (*t).cases[i*(*t).dimx+k].vie;
			fprintf(fic ,"%d ", recup);
			recup = (*t).cases[i*(*t).dimx+k].groupe_decor;
			fprintf(fic ,"%d\n", recup);
		}
		fprintf(fic ,"\n");
	}
	for (i=0; i< (*t).dimy;i++)
	{
		for (k=0; k< (*t).dimx; k++)
		{
			if ((*t).cases[i*(*t).dimx+k].lunite == NULL)
			{
				fprintf(fic ,"0\n");
			}
			else
			{
				recup = (*(*t).cases[i*(*t).dimx+k].lunite).type;
				fprintf(fic ,"%d ", recup);
				recup = (*(*t).cases[i*(*t).dimx+k].lunite).vie;
				fprintf(fic ,"%d ", recup);
				recup2 = (*(*t).cases[i*(*t).dimx+k].lunite).attaque;
				fprintf(fic ,"%f ", recup2);
				recup = (*(*t).cases[i*(*t).dimx+k].lunite).defense;
				fprintf(fic ,"%d ", recup);
				recup = (*(*t).cases[i*(*t).dimx+k].lunite).deplacement;
				fprintf(fic ,"%d ", recup);
				recup = (*(*t).cases[i*(*t).dimx+k].lunite).equipe;
				fprintf(fic ,"%d ", recup);
				recup = (*(*t).cases[i*(*t).dimx+k].lunite).utilise;
				fprintf(fic ,"%d\n", recup);
				
			}
		}
		fprintf(fic ,"\n");
	}
	fclose(fic);
}

int VerificationMapFaite(Jeu * j, const char * nomfic)
{
	FILE * fic = fopen(nomfic,"r");
	int ok = 1;
	int nb = 0;
	int recup;
	
	if(fic != NULL)
	{
		while (ok == 1)
		{
			ok = fscanf(fic ,"%d\n", &recup);
			if (ok != -1)
			{
				if (recup == (*j).mapencours)
				{
					ok = 0;
				}
				nb++;
			}
		}
		
		if (ok == -1)
		{
			if ((*j).mapencours != 10)
			{
				fclose(fic);
				fic = fopen(nomfic,"a");
				fprintf(fic ,"%d\n", (*j).mapencours);
				fclose(fic);
				nb++;
				if (nb == 8)
				{	
					return 1;
				}
			}
		}
	}
	else
	{
		if ((*j).mapencours != 10)
		{
			fic = fopen(nomfic,"a");
			fprintf(fic ,"%d\n", (*j).mapencours);
			fclose(fic);
		}
	}
	return 0;
}

void ChargementMapFaite(Jeu * j,int tableaumap[8],const char * nomfic)
{
	FILE * fic = fopen(nomfic,"r");
	int i;
	int recup;
	int ok = 1;
	for (i =0; i< 8; i++)
	{
		tableaumap[i] = 0;
	}
	if(fic != NULL)
	{
		while (ok == 1)
		{
			ok = fscanf(fic ,"%d\n", &recup);
			if (ok != -1)
			{
				tableaumap[recup-1] = 1;
				
			}
			
		}
		fclose(fic);
	}
}

void SauvegardeOption (int musique, int bruitage, const char * nomfic)
{
	FILE * fic = fopen(nomfic,"w");
	if(fic == NULL)
	{
		printf("ERROR \n");
		exit(EXIT_FAILURE);	
	}
	else
	{
		fprintf(fic ,"%d %d", musique,bruitage);
	}
	fclose(fic);
}

void ChargementOption (int * musique, int * bruitage, const char * nomfic)
{
	FILE * fic = fopen(nomfic,"r");
	int recup;
	if(fic == NULL)
	{
		fclose(fic);
		fic = fopen(nomfic,"w");
		if(fic == NULL)
		{
			printf("ERROR \n");
			exit(EXIT_FAILURE);	
		}
		else
		{
			fprintf(fic ,"%d %d", 1,1);
			*musique = 1;
			*bruitage = 1;
		}
	}
	else
	{
		fscanf(fic ,"%d ",&recup);
		*musique = recup;
		fscanf(fic ,"%d ",&recup);
		*bruitage = recup;
	}
	fclose(fic);
}
void VidageMapFaite(const char * nomfic)
{
	remove(nomfic);
}


void AjouterDecorEditeurJeu (Jeu * j, int selection, int x,int y)
{
	Terrain * t = ObtientTerrainJeu (j);
	Cases * c = ObtientCasesTerrain (t,x,y);
	
	assert(0<=x && x<(*t).dimx);
	assert(0<=y && y<(*t).dimy);
	if ((*c).lunite == NULL)
	{
		switch (selection)
		{
			case 1 :
				ModificationDecor (c, 0, 0);
			break;
			case 2 :
				ModificationDecor (c, 1, 0);
			break;
			case 3 :
				ModificationDecor (c, 2, 0);
			break;
			case 4 :
				ModificationDecor (c, 9, 0);
			break;
		 	
		}
	}	
}

void AjouterUniteEditeurJeu (Jeu * j, int selection, int x,int y)
{
	Terrain * t = ObtientTerrainJeu (j);
	Cases * c = ObtientCasesTerrain (t,x,y);
	
	assert(0<=x && x<(*t).dimx);
	assert(0<=y && y<(*t).dimy);
	if ((*c).type_decor == 0)
	{
		if (selection == 0)
		{
			if ((*c).lunite != NULL)
			{
				ModificationNombreUnites (&(*j).tableau_de_joueurs[(*(*c).lunite).equipe],-1);
				DestructionUniteCases (c);
				
			}
		}
		else
		{
			if ((*c).lunite == NULL)
			{
				(*c).lunite = (Unite*) malloc (sizeof (Unite));
				if (selection <= 5)
				{
					 InitialisationUnite ((*c).lunite,selection ,1);
				}
				else
				{
					 InitialisationUnite ((*c).lunite,selection-5 ,0);
				}
				(*(*c).lunite).utilise = 0;
				ModificationNombreUnites (&(*j).tableau_de_joueurs[(*(*c).lunite).equipe],1);
			}
			else
			{
				if (selection <= 5)
				{
					if ((*(*c).lunite).equipe != 1)
					{
						ModificationNombreUnites (&(*j).tableau_de_joueurs[0],-1);
						ModificationNombreUnites (&(*j).tableau_de_joueurs[1],1);
					}
					InitialisationUnite ((*c).lunite,selection ,1);
					(*(*c).lunite).utilise = 0;
				}
				else
				{
					if ((*(*c).lunite).equipe != 0)
					{
						ModificationNombreUnites (&(*j).tableau_de_joueurs[1],-1);
						ModificationNombreUnites (&(*j).tableau_de_joueurs[0],1);
					}
					 InitialisationUnite ((*c).lunite,selection-5 ,0);
					 (*(*c).lunite).utilise = 0;
				}
			}
		}
	}
}
